home *** CD-ROM | disk | FTP | other *** search
/ ADA Programming Guide / ADA Programming Guide.iso / ada_gwu / cwkgraph.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-30  |  24.8 KB  |  935 lines
  1.  
  2.  
  3. /*
  4.     GWMON Parallel Ada Monitor for 386/486 PCs   
  5.     Copyright (C) 1993, Charles W. Kann  & Michael Bliss Feldman
  6.                         ckann@seas.gwu.edu mfeldman@seas.gwu.edu
  7.  
  8.     This program is free software; you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License as published by
  10.     the Free Software Foundation; either version 2 of the License.
  11.  
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21. */
  22.  
  23. #include "ed.h"
  24. #include "keydef.h"
  25.  
  26. #if 0
  27. #define ROWS 10
  28. #endif
  29. static int ROWS = 10;
  30. #define COLS 78
  31. #define MAX_WINDOWS 12
  32. static char video[4000];
  33. static AVL_WIN_PTR  top_win, output_win;
  34. static struct rccoord text_pos;
  35. static int next_monitor;
  36. static int SAVE_WIN_SIZE;
  37.  
  38. /*
  39.    Structures for Block names for monitor windows titles.  Note that the
  40.    Block names structure does not malloc the names.  I was afraid that
  41.    malloc would fragment core too much with alot of funny sized pieces of
  42.    memory.
  43. */
  44.  
  45. #define MAX_LEVELS 200
  46. #define NAME_SIZE 32
  47. static char Block_Name[MAX_LEVELS][NAME_SIZE];
  48.  
  49. #define NEWLINE 0x0a
  50. #define ESCAPE 0x1b
  51.  
  52. void CWK_DEL_WINDOW();
  53. static struct {
  54.     AVL_WIN_PTR w;
  55.     int used;
  56.     COORD wind_coord;
  57.     int monitor;
  58. } window[MAX_WINDOWS];
  59.     
  60. static int SCROLL_LINE = 0, escape_sequence = 0;
  61.  
  62. void CWK_ERASE_ALL_MON_WIN();
  63. void CWK_ERASE_MON_WIN();
  64. void CWK_CLEANUP_MON();
  65.  
  66. CWK_MOVE_INPUT( fp )
  67. FILE *fp;
  68. {
  69.     struct rccoord text_p;
  70.     if ( ! isatty( fileno(fp) )) 
  71.     return;
  72.  
  73.  
  74.     text_p= _gettextposition();
  75.     text_p.col = 1;
  76.     text_p.row++;
  77.     if (text_p.row >= ROWS) {
  78.         SCROLL_LINE = 1;
  79.     text_p.row--;
  80.         }
  81.     _settextposition(text_p.row, text_p.col);
  82. }
  83.  
  84. CWK_PUTC( inchar, fp )
  85. int inchar;
  86. FILE *fp;
  87. {
  88.     struct rccoord text_p;
  89.     static int screen_row, screen_col;
  90.     static char next_char;
  91.     char TextString[2];
  92.  
  93.     /*
  94.     if this file is not a tty, write the character and continue
  95.     */
  96.  
  97.     if ( ! isatty( fileno(fp) )) {
  98.     fputc(inchar,fp);fflush(fp);
  99.     return;
  100.      }
  101.  
  102.  
  103.     /*
  104.     Cheap kludge to handle ascii control sequences
  105.     */
  106.  
  107.     if ( escape_sequence ) {
  108.     switch ( next_char ) {
  109.        case '[' :
  110.         if ( inchar == '[' ) {
  111.             next_char = '1';
  112.             return;
  113.         }
  114.         break;
  115.        case '1' :
  116.         if ( inchar == 'J' ) {
  117.             int i;
  118.             char buf[80];
  119.  
  120.             escape_sequence = 0;
  121.             sprintf(buf,"%-78s"," ");
  122.             for(i = 1; i <= ROWS; ++i) {
  123.                 _settextposition(i, 1 );
  124.                 _outtext(buf);
  125.             }
  126.             _settextposition(1, 1 );
  127.             return;
  128.         }
  129.         else if ( inchar == ';' ) {
  130.             next_char = '2';
  131.             return;
  132.         }
  133.         else if (isdigit( inchar )) {
  134.             screen_row = screen_row * 10 + (inchar - '0');
  135.             return;
  136.         }
  137.         break;
  138.         case '2' :
  139.         if ( inchar == 'f' ) {
  140.             escape_sequence = 0;
  141.                 _settextposition(screen_row, screen_col);
  142.             return;
  143.         }
  144.         else if ( isdigit( inchar )) {
  145.             screen_col = screen_col * 10 + (inchar - '0');
  146.             return;
  147.         }
  148.         break;
  149.         default:
  150.         break;
  151.     }
  152.     escape_sequence = 0;
  153.     }
  154.  
  155.     if ( inchar != ESCAPE ) {
  156.         text_p= _gettextposition();
  157.         if ( SCROLL_LINE ) {
  158.             _scrolltextwindow(_GSCROLLUP);
  159.         SCROLL_LINE = 0;
  160.             }
  161.     }
  162.  
  163.     if ( inchar == ESCAPE ) {
  164.     SCROLL_LINE = 0;
  165.     escape_sequence = 1;
  166.     screen_row = screen_col = 0;
  167.     next_char = '[';
  168.     return;
  169.     }
  170.  
  171.     else if ( ( inchar == NEWLINE ) || ( inchar == CTRL_M ) ) {
  172.     text_p.col = 1;
  173.     text_p.row++;
  174.         if (text_p.row >= ROWS) {
  175.             SCROLL_LINE = 1;
  176.         text_p.row--;
  177.             }
  178.         }
  179.     else {
  180.         sprintf( TextString, "%c", inchar );
  181.         _outtext( TextString );
  182.         text_p.col++;
  183.     if (  text_p.col > COLS ) {
  184.         text_p.col = 1;
  185.         text_p.row++;
  186.         }
  187.     }
  188.     if (text_p.row >= ROWS) {
  189.         SCROLL_LINE = 1;
  190.     text_p.row--;
  191.         }
  192.     _settextposition(text_p.row, text_p.col);
  193. }
  194.  
  195. static int CWK_MON_GET_WIN(monitor)
  196. int monitor;
  197. {
  198.     int i;
  199.     static int last_used;
  200.     
  201.     for (i = 0; i < Windows_Used; i++) {
  202.         if ( ! window[i].used ) {
  203.         window[i].used = 1;
  204.         window[i].monitor = monitor;
  205.         last_used = i;
  206.         return i;
  207.         }
  208.         }
  209.     return -1;
  210.     
  211. }
  212.  
  213. static void CWK_MAKE_WINDOW(title, win_no)
  214. char *title;
  215. int win_no;
  216. {
  217.     window[win_no].w = AVL_MAKE_WINDOW( title, window[win_no].wind_coord.x1,
  218.                 window[win_no].wind_coord.y1, 
  219.                 window[win_no].wind_coord.x2, 
  220.                 window[win_no].wind_coord.y2, 
  221.                 1, 15 );
  222. }
  223.  
  224. static void CWK_SAVE_TEXT_POS()
  225. {
  226.     text_pos = _gettextposition();
  227. }
  228.     
  229. static void CWK_RES_TEXT_POS()
  230. {
  231.     _settextwindow(2,2,ROWS,79);
  232.     _settextposition(text_pos.row, text_pos.col);
  233. }
  234.  
  235. MON_REC_PTR CWK_CREATE_MON_WIN( title, display )
  236. char *title;
  237. int display;
  238. {
  239.     CWK_SAVE_TEXT_POS();
  240.     CWK_MONS[next_monitor].title = malloc( strlen( title ) + 1 );
  241.     strcpy( CWK_MONS[next_monitor].title, title );
  242.     if ( display )
  243.     {
  244.         CWK_MONS[next_monitor].mon_win = CWK_MON_GET_WIN(next_monitor);
  245.         if (CWK_MONS[next_monitor].mon_win == -1)
  246.         {
  247.         CWK_MONS[next_monitor].WON = -1;
  248.         }
  249.         else
  250.         {
  251.         CWK_MONS[next_monitor].WON = 1;
  252.         CWK_MAKE_WINDOW( title, CWK_MONS[next_monitor].mon_win );
  253.         }
  254.     }
  255.     else
  256.         CWK_MONS[next_monitor].WON = -1;
  257.  
  258.     CWK_RES_TEXT_POS();
  259.     return &CWK_MONS[next_monitor++];
  260. }
  261.  
  262. /*************************************************************************/
  263. /*    Routines to draw the monitor windows                             */
  264. /*************************************************************************/
  265. void CWK_REMOVE_BLOCK ( tmp_mon )
  266. MON_REC *tmp_mon;
  267. {
  268.     CWK_SAVE_TEXT_POS();
  269.  
  270.     CWK_ERASE_MON_WIN(tmp_mon);
  271.  
  272.      Block_Level--;
  273.      if ( Block_Level < 0 )
  274.      {
  275.         char msg[80];
  276.             sprintf( msg, "Internal Error, leaving too many blocks" );
  277.         CWK_CLEANUP_MON( -1, msg );
  278.     }
  279.     *Block_Name[Block_Level] = '\0';
  280.     CWK_RES_TEXT_POS();
  281. }
  282.  
  283. void CWK_DRAW_PROC_WIN( tmp_mon, enter_or_exit )
  284. MON_REC *tmp_mon;
  285. int enter_or_exit;
  286. {
  287.     int i, First_Win_On_Screen;
  288.  
  289.     CWK_SAVE_TEXT_POS();
  290.  
  291.     if ( ! enter_or_exit )
  292.     {
  293.         strcpy( Block_Name[Block_Level], tmp_mon->title );
  294.         Block_Level++;  
  295.     }
  296.     
  297.  
  298.     if ( Block_Level >= Windows_Used )
  299.     {
  300.         WIN_SIZE = SAVE_WIN_SIZE - Windows_Used;
  301.         tmp_mon->mon_win = Windows_Used - 1;
  302.         First_Win_On_Screen = Block_Level - Windows_Used;
  303.         CWK_ERASE_ALL_MON_WIN();
  304.         tmp_mon->WON = 1;
  305.         for ( i = 0; i < Windows_Used; ++i )
  306.         {
  307.         window[i].used = 1;
  308.             CWK_MAKE_WINDOW( Block_Name[First_Win_On_Screen+i], i );
  309.         }
  310.     }
  311.     else if ( Block_Level > 0 )
  312.     {
  313.         WIN_SIZE = SAVE_WIN_SIZE - Block_Level;
  314.         tmp_mon->mon_win = Block_Level - 1;
  315.         if ( enter_or_exit )
  316.             CWK_ERASE_MON_WIN(tmp_mon);
  317.         window[Block_Level-1].used = 1;
  318.         tmp_mon->WON = 1;
  319.         CWK_MAKE_WINDOW( Block_Name[Block_Level-1], Block_Level-1);
  320.     }
  321.  
  322.     CWK_RES_TEXT_POS();
  323.  
  324.     /*
  325.         Note that we have to redraw the time, otherwise it
  326.         doesn't look right.
  327.     */
  328.     CWK_REPORT_TIME(Run_Total_Time);
  329. }
  330.  
  331. void CWK_DRAW_MON_WIN(tmp_mon)
  332. MON_REC   *tmp_mon;
  333. {
  334.     CWK_SAVE_TEXT_POS();
  335.     tmp_mon->mon_win = CWK_MON_GET_WIN(next_monitor);
  336.     if (tmp_mon->mon_win == -1)
  337.     {
  338.         tmp_mon->WON = -1;
  339.     }
  340.     else
  341.     {
  342.         tmp_mon->WON = 1;
  343.         CWK_MAKE_WINDOW( tmp_mon->title, tmp_mon->mon_win );
  344.     }
  345.     CWK_RES_TEXT_POS();
  346. } 
  347.  
  348. void CWK_ERASE_ALL_MON_WIN()
  349. {
  350.     int i;
  351.     CWK_SAVE_TEXT_POS();
  352.     for (i = MAX_WINDOWS - 1; i >= 0; i--) {
  353.         if ( window[i].used ) {
  354.         window[i].used = 0;
  355.         window[i].monitor = -1;
  356.         CWK_DEL_WINDOW(i); 
  357.         }
  358.         }
  359.     CWK_RES_TEXT_POS();
  360. }
  361.  
  362. void CWK_ERASE_MON_WIN(tmp_mon)
  363. MON_REC   *tmp_mon;
  364. {
  365. #if 0
  366.     {
  367.     char msg[80];
  368.     sprintf( msg, " in erase_mon_win, name = %s, used =%d\n", 
  369.         tmp_mon->title, window[tmp_mon->mon_win].used );
  370.     _outtext(msg);
  371.     getch();
  372.     }
  373. #endif
  374.     if ( window[tmp_mon->mon_win].used ) 
  375.     {
  376.         CWK_SAVE_TEXT_POS();
  377.         window[tmp_mon->mon_win].used = 0;
  378.         window[tmp_mon->mon_win].monitor = -1;
  379.         CWK_DEL_WINDOW(tmp_mon->mon_win);
  380.         CWK_RES_TEXT_POS();
  381.     }
  382. }
  383.  
  384. void CWK_DEL_MON_WIN(tmp_mon)
  385. MON_REC   *tmp_mon;
  386. {
  387.     CWK_SAVE_TEXT_POS();
  388.     free( CWK_MONS[next_monitor].title );
  389.     window[tmp_mon->mon_win].used = 0;
  390.     tmp_mon->WON = -1;
  391.     CWK_DEL_WINDOW(tmp_mon->mon_win);
  392.     CWK_RES_TEXT_POS();
  393. }
  394.  
  395. void CWK_INIT_MON()
  396. {
  397.     int i;
  398.     char buf[80];
  399.  
  400.         _settextrows( 25 );
  401.         _clearscreen( _GCLEARSCREEN );
  402.  
  403.     top_win = AVL_MAKE_WINDOW( "", 1, 1, 24, 80, 1, 15 );
  404.     output_win = AVL_MAKE_WINDOW( " GWU ADA MONITOR - Type Ctrl h for help, ESC to leave", 1, 1, ROWS+1, 80, 1, 15 );
  405.  
  406.     /*  make the rest of the screen Blue so it looks ok  */
  407.  
  408.     _settextwindow(ROWS+2,1,24,80);
  409.     _setbkcolor( 1 );
  410.     _settextcolor( 15 );
  411.     sprintf( buf, "%80.80s", " " );
  412.     for(i = 1; i < 25 - (ROWS - 2); ++i) {
  413.         _settextposition(i, 1 );
  414.         _outtext(buf);
  415.         }
  416.     
  417.     _settextrows(11);
  418.     _settextwindow(2,2,ROWS,79);
  419.     _settextposition(1,1);
  420.     next_monitor = 0;
  421. }
  422.  
  423. /*
  424. */
  425.  
  426. void CWK_CLEANUP_MON(status, msg)
  427. int status;
  428. char *msg;
  429. {
  430.     AVL_WIN_PTR w;
  431.     int ch;
  432.  
  433.     w = AVL_MAKE_WINDOW( "", 4,15,9,76, 1, 15);
  434.         _settextposition(1, 1);
  435.     if ( status < 0 )
  436.     {
  437.             _outtext(msg);
  438.         ch = getch();
  439.         AVL_DEL_WINDOW( w );
  440.         AVL_DEL_WINDOW( top_win );
  441.         exit(status);
  442.     }
  443.     else if ( status )
  444.             _outtext("Do you wish to Exit (y/n)");
  445.     else
  446.     {
  447.             _outtext("Execution completed");
  448.         ch = getch();
  449.         AVL_DEL_WINDOW( w );
  450.         AVL_DEL_WINDOW( top_win );
  451.         exit(status);
  452.     }
  453.     ch = getch();
  454.     AVL_DEL_WINDOW( w );
  455.     if (( ch == 'y') ||  (ch == 'Y')) {
  456.         AVL_DEL_WINDOW( top_win );
  457.         exit(status);
  458.     }
  459. }
  460.  
  461. void CWK_WRITE_LINE( MON, line, text_line )
  462. MON_REC_PTR MON;
  463. int line;
  464. char *text_line;
  465. {
  466.     if ( MON->WON == -1 )
  467.         return;
  468.     CWK_SAVE_TEXT_POS();
  469.     if ( ! MON->WON ) {
  470.         MON->mon_win = CWK_MON_GET_WIN(next_monitor);
  471.         if ( MON->mon_win == -1 )
  472.             return;
  473.             CWK_MAKE_WINDOW( MON->title, MON->mon_win );
  474.         MON->WON = 1;
  475.     }
  476.  
  477.     /*
  478.         This statement because necessary when procedure monitoring
  479.         came in.  This is because the WON flag is not meaningful to
  480.         the monitoring, and we don't want to use the window if it
  481.         no longer exists.
  482.     */
  483.     if ( MON->mon_win == -1 )
  484.         return;
  485.  
  486.     _settextwindow(window[MON->mon_win].wind_coord.x1+1,
  487.         window[MON->mon_win].wind_coord.y1+1,
  488.         window[MON->mon_win].wind_coord.x2,
  489.         window[MON->mon_win].wind_coord.y2);
  490.     _settextposition(line,5);
  491.     _outtext(text_line);
  492.     CWK_RES_TEXT_POS();
  493. }
  494.  
  495. void CWK_CUR_LINE( MON, line, string )
  496. MON_REC_PTR MON;
  497. int line;
  498. char *string;
  499. {
  500.     if ( MON->WON == -1 )
  501.         return;
  502.     CWK_SAVE_TEXT_POS();
  503.     if ( ! MON->WON ) {
  504.         MON->mon_win = CWK_MON_GET_WIN(next_monitor);
  505.         if ( MON->mon_win == -1 )
  506.             return;
  507.             CWK_MAKE_WINDOW( MON->title, MON->mon_win );
  508.         MON->WON = 1;
  509.     }
  510.  
  511.     /*
  512.         This statement because necessary when procedure monitoring
  513.         came in.  This is because the WON flag is not meaningful to
  514.         the monitoring, and we don't want to use the window if it
  515.         no longer exists.
  516.     */
  517.     if ( MON->mon_win == -1 )
  518.         return;
  519.     
  520.     _settextwindow(window[MON->mon_win].wind_coord.x1+1,
  521.         window[MON->mon_win].wind_coord.y1+1,
  522.         window[MON->mon_win].wind_coord.x2,
  523.         window[MON->mon_win].wind_coord.y2);
  524.     _settextposition(line,1);
  525.     strncpy( string, string, 3);
  526.     _outtext(string);
  527.     CWK_RES_TEXT_POS();
  528. }
  529.  
  530. void CWK_DEL_WINDOW(int win_num)
  531. {
  532.     struct rccoord pos;
  533.     char format[80], buf[81];
  534.     int i;
  535.  
  536.     _settextwindow(window[win_num].wind_coord.x1, 
  537.         window[win_num].wind_coord.y1, window[win_num].wind_coord.x2, 
  538.         window[win_num].wind_coord.y2);
  539.  
  540.     sprintf(format,"%c-%ds",'%', ( window[win_num].wind_coord.y2 - 
  541.         window[win_num].wind_coord.y1) + 1 );
  542.     _setbkcolor(window[win_num].w -> bk);
  543.     _settextcolor(window[win_num].w -> co);
  544.     sprintf(buf,format," ");
  545.     for(i = 1; 
  546.         i <= (window[win_num].wind_coord.x2 -
  547.         window[win_num].wind_coord.x1 + 1); 
  548.         ++i) {
  549.             _settextposition(i, 1 );
  550.             _outtext(buf);
  551.         }
  552.     free(window[win_num].w);
  553. }
  554.  
  555. void print_license()
  556. {
  557.     AVL_WIN_PTR w;
  558.     int ch;
  559.  
  560.     w = AVL_MAKE_WINDOW( "License", 1,4,18,76, 1, 15);
  561.         _settextposition(1, 1);
  562.         _outtext("GWUMON Copyright (C) 1993 Charles W. Kann  & Michael Bliss Feldman \n");
  563.         _outtext("                          ckann@seas.gwu.edu mfeldman@seas.gwu.edu \n");
  564.         _outtext( "This program is free software; you can redistribute it and/or modify\n" );
  565.         _outtext( "it under the terms of the GNU General Public License as published by\n" );
  566.         _outtext( "the Free Software Foundation; either version 2 of the License, or\n" );
  567.         _outtext( " any later version. \n\n" );
  568.  
  569.         _outtext( "This program is distributed in the hope that it will be useful,\n" );
  570.         _outtext( "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" );
  571.         _outtext( "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n" );
  572.         _outtext( "GNU General Public License for more details.\n\n" );
  573.  
  574.         _outtext( "You should have received a copy of the GNU General Public License\n" );
  575.         _outtext( "along with this program; if not, write to the Free Software\n" );
  576.         _outtext( "Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n" );
  577.  
  578.     ch = getch();
  579.     AVL_DEL_WINDOW( w );
  580.  
  581. }
  582.  
  583. /*************************************************************************
  584. *
  585. *    This section of code prints out any help type screens (ie. ones
  586. *    which just give straight text in a window which is put up for
  587. *    a single clock cycle.
  588. *
  589. *************************************************************************/
  590.  
  591. void print_setup_help()
  592. {
  593.     AVL_WIN_PTR w;
  594.     int ch;
  595.  
  596.     w = AVL_MAKE_WINDOW( "Setup Help", 3,5,22,75, 1, 15);
  597.         _settextposition(1, 1);
  598.     _outtext("The following can be set from the setup Screen                     \n");
  599.         _outtext("Delay Rate - This is the amount to delay the monitor on each clock \n");
  600.         _outtext("             cycle. Note that a clock cycle is one pass through    \n");
  601.         _outtext("             the interpreter.                                      \n");
  602.         _outtext("Cycles for Reporting Exec % - If Type of Monitoring is Exec %, then\n");
  603.         _outtext("             this tells how many cycles to run between reporting\n");
  604.     _outtext("Delay time - If the Type of Delay is set to Scaled then this is \n");
  605.     _outtext("             the number of clock ticks to be interpreted as     \n");
  606.     _outtext("             1 second                                           \n");
  607.     _outtext("RR statments - If Type of Tasking is set to Round Robin, then   \n");
  608.     _outtext("             this is the number of cycles between task switches \n");
  609.     _outtext("Type of Tasking - This is the task type model.  It can be set   \n");
  610.     _outtext("             to Round Robin or Run Til Blocked                  \n");
  611.     _outtext("Type of Delay - The type of delay can be either Real ( 1 second \n");
  612.     _outtext("             is a real time second), or Scaled ( 1 second is    \n");
  613.     _outtext("             some number of clock cycles                         \n");
  614.     ch = getch();
  615.     _outtext("Type of Monitoring - This can be either None (No monitoring is   \n");
  616.     _outtext("             used), Line (show the lines of code as they are     \n");
  617.     _outtext("             executed ),  or Exec % (show the execution % for    \n");
  618.     _outtext("             each task at the interval specified above)          \n");
  619.     _outtext("Line Trace - Turns Line Tracing on.  This stops the monitor after\n");
  620.     _outtext("             each line on the current monitor screen is executed \n");
  621.     _outtext("Task Trace - Turns Task Tracing on.  This stops the monitor after\n");
  622.     _outtext("             each task switch for a task on the current monitor  \n");
  623.     _outtext("             screen.                                             \n");
  624.     _outtext("Type of Monitoring Window - Type of window to use  in Line       \n");
  625.     _outtext("             Monitoring Mode.  You can show 1 - 4 tasks in       \n");
  626.     _outtext("             4 different ways.      \n");
  627.  
  628.     ch = getch();
  629.     AVL_DEL_WINDOW( w );
  630. }
  631.  
  632. void print_help()
  633. {
  634.     AVL_WIN_PTR w;
  635.     int ch;
  636.  
  637.     w = AVL_MAKE_WINDOW( "Help", 5,15,18,70, 1, 15);
  638.         _settextposition(1, 1);
  639.         _outtext("Up Arr - increase speed    Dn Arr - decrease speed\n");
  640.         _outtext("ctrl l - line step         ctrl h - help screen\n");
  641.         _outtext("ctrl t - task step         ctrl a - control screen\n");
  642.         _outtext("ctrl b - stop monitoring   ctrl d - setup screen\n");
  643.         _outtext("ctrl r - resize window \n");
  644.         _outtext("ctrl c or ESC - stop the execution of the monitor\n\n");
  645.         _outtext("Status Codes \n");
  646.         _outtext("R - Wait on Rendezvous      M - Rendezvous Meet\n");
  647.         _outtext("D - Wait on Delay           * - Task Ready to Run\n");
  648.         _outtext("--> Task currently running ");
  649.  
  650.     ch = getch();
  651.     AVL_DEL_WINDOW( w );
  652.     
  653. }
  654.  
  655. /***********************************************************************/
  656. /*   Control Window code is contained here.                            */
  657. /***********************************************************************/
  658.  
  659. static AVL_WIN_PTR Control_Window;
  660. CWK_CONTROL_TASK( Schedule_Type, Task_Type, Execution_Time, Report_Time )
  661. char *Schedule_Type, *Task_Type;
  662. int Execution_Time, Report_Time;
  663. {
  664.     char msg[100];
  665.  
  666.     CWK_SAVE_TEXT_POS();
  667.     Control_Window = AVL_MAKE_WINDOW( "Task Control -- use t to toggle task, Esc to quit", 12, 5, 24, 75, 1, 15);
  668.         _settextposition(1, 1);
  669.         sprintf(msg, "Scheduling : %s        Current task : %s\n",
  670.             Schedule_Type, Task_Type );
  671.         _outtext(msg);
  672.         sprintf(msg, "Execution Time : %5d   Time to Report: %5d\n", 
  673.         Execution_Time, Report_Time );
  674.         _outtext(msg);
  675. }
  676.  
  677. CWK_PRINT_CONTROL_LINE( iline, msg )
  678. int iline;
  679. char *msg;
  680. {
  681.     _settextposition(iline, 1);
  682.     _outtext(msg);
  683.     _settextposition(iline, 1);
  684. }
  685. CWK_DEL_CONTROL ()
  686. {
  687.     AVL_DEL_WINDOW( Control_Window );
  688.     CWK_RES_TEXT_POS();
  689. }
  690.  
  691. /***********************************************************************/
  692. /*   Exception Reports are printed out here                   */
  693. /***********************************************************************/
  694.  
  695. CWK_Report_Exception( task_name, msg )
  696. char *task_name, *msg;
  697. {
  698.     char msg1[80];
  699.     AVL_WIN_PTR Win;
  700.     CWK_SAVE_TEXT_POS();
  701.     Win = AVL_MAKE_WINDOW( "Exception Raised", 6, 1, 11, 80, 1, 15);
  702.         _settextposition(2, 1);
  703.     sprintf( msg1, "Exception Raised in task name %s\n", task_name );
  704.     _outtext( msg1 );
  705.     _outtext( msg );
  706.     getch();
  707.     AVL_DEL_WINDOW( Win );
  708.     CWK_RES_TEXT_POS();
  709.     
  710. }
  711.  
  712. /***********************************************************************/
  713. /*   Execution Pct Report is contained here                            */
  714. /***********************************************************************/
  715.  
  716. CWK_REPORT_TIME( execution_time )
  717. long execution_time;
  718. {
  719.     char msg[100];
  720.     int i, start;
  721.     static int save_step_rate;
  722.  
  723.     if (save_step_rate == step_rate )
  724.     {
  725.         save_step_rate = step_rate;
  726.         return;
  727.     }
  728.     CWK_SAVE_TEXT_POS();
  729.     _settextwindow(24,35,24,79);
  730.     start = 16 - step_rate ;
  731.         _settextposition(1, 1);
  732.     sprintf( msg, "Speed " );
  733.     _outtext( msg );
  734.     for ( i = 7; i < start; ++i )
  735.     {
  736.             _settextposition(1, i);
  737.         _outtext( "=" );
  738.     }
  739.  
  740.     for ( i = start; i <= 15; ++i )
  741.     {
  742.             _settextposition(1, i);
  743.         _outtext( "." );
  744.     }
  745. #if 0
  746.         _settextposition(1, 20);
  747.     sprintf( msg, "Cycles Exec %d", execution_time );
  748.     _outtext( msg );
  749. #endif
  750.     CWK_RES_TEXT_POS();
  751. }
  752.  
  753. /***********************************************************************/
  754. /*   Execution Pct Window code is contained here.                      */
  755. /***********************************************************************/
  756.  
  757. static AVL_WIN_PTR Exec_Pct_Window;
  758. static int Exec_WON = 0;
  759. CWK_EXEC_PCT()
  760. {
  761.     char msg[100];
  762.     
  763.     if ( Exec_WON )
  764.         return;
  765.     Exec_WON = 1;
  766.  
  767.     CWK_SAVE_TEXT_POS();
  768.     Exec_Pct_Window = AVL_MAKE_WINDOW( "Exec Pct Viewer -- Use Ctrl-B to quit", 12, 1, 24, 80, 1, 15);
  769.     _settextwindow(13,2,23,79);
  770.         _settextposition(1, 1);
  771.     sprintf( msg, " #  Name    St  %c   #  Name    St  %c   #  Name    St  %c   #  Name    St  %c " , '%', '%', '%', '%'); 
  772.     _outtext( msg );
  773.     CWK_RES_TEXT_POS();
  774. }
  775.  
  776.  
  777. CWK_EXEC_PRINT_LINE( line, msg )
  778. int line;
  779. char *msg;
  780. {
  781.     CWK_SAVE_TEXT_POS();
  782.     _settextwindow(13,2,23,79);
  783.         _settextposition(line, 1);
  784.     _outtext( msg );
  785.     CWK_RES_TEXT_POS();
  786. }
  787.  
  788. CWK_DEL_EXEC_PCT()
  789. {
  790.     CWK_SAVE_TEXT_POS();
  791.     AVL_DEL_WINDOW( Exec_Pct_Window );
  792.     Exec_WON = 0;
  793.     CWK_RES_TEXT_POS();
  794. }
  795.  
  796. /***********************************************************************
  797. *
  798. *    This section of code initializes the monitor windows.  It puts
  799. *    the windows on the screen, and sets up the structures so that
  800. *    they can be used by the CUR_LINE and WRITE_LINE routines.
  801. *
  802. ***********************************************************************/
  803.  
  804. CWK_SETUP_WINDOWS()
  805. {
  806.     int i; 
  807.  
  808.     for ( i = 0; i < MAX_WINDOWS; ++i) 
  809.         window[i].used = 0;
  810.     
  811.     /*
  812.         Procedure monitoring.  The windows are inset one row and
  813.         column as the procedures continue down.
  814.     */
  815.     if ( ! task_monitor )
  816.     {
  817.         /*
  818.         For procedure monitoring, set up the windows based on the
  819.         whether the Large_Monitor (ie, the monitor is 20 lines) or
  820.         small monitor (ie. the monitor is 13 lines) is choosen.
  821.  
  822.         Note that the SAVE_WIN_SIZE is 1 larger than the maximum
  823.         window size.  This is because the first window has a block
  824.         level of 1, and will thus make the WIN_SIZE =SAVE_WIN_SIZE -1
  825.         */
  826.         if ( Large_Monitor )
  827.         {
  828.             Windows_Used = 12;
  829.         SAVE_WIN_SIZE = 19;
  830.         ROWS = 3;
  831.         }
  832.         else
  833.         {
  834.             Windows_Used = 5;
  835.             SAVE_WIN_SIZE = 12;
  836.         ROWS = 10;
  837.         }
  838.         LINE_SIZE = 68;
  839.  
  840.         if ( Large_Monitor )
  841.         {
  842.             for ( i = 0; i < MAX_WINDOWS; ++i) 
  843.             {
  844.             window[i].wind_coord.x1 = 5+i; window[i].wind_coord.y1 = 1;
  845.             window[i].wind_coord.x2 = 24; window[i].wind_coord.y2 = 80-i;
  846.             }
  847.         }
  848.         else
  849.         {
  850.             for ( i = 0; i < MAX_WINDOWS; ++i) 
  851.             {
  852.             window[i].wind_coord.x1 = 12+i; window[i].wind_coord.y1 = 1;
  853.             window[i].wind_coord.x2 = 24; window[i].wind_coord.y2 = 80-i;
  854.             }
  855.         }
  856.     }
  857.  
  858.     /*
  859.         Task monitoring windows.  This sets up the four types of
  860.         task windows.  The definition of the windows is completely
  861.           done here, and this should be all that is needed to change
  862.         to change the sizes or definitions of the windows.  NOTE:
  863.         You will have to change the MONITOR definition (ie. the
  864.         ROWS define) if you are going to increase the size of the
  865.         monitor windows.
  866.     */
  867.     else
  868.     {
  869.         switch ( monitor_window_type ) {
  870.             case 0 :
  871.             Windows_Used = 4;
  872.             WIN_SIZE = 5;
  873.             LINE_SIZE = 28;
  874.             window[0].wind_coord.x1 = 12; window[0].wind_coord.y1 = 1;
  875.             window[0].wind_coord.x2 = 18; window[0].wind_coord.y2 = 40;
  876.             window[1].wind_coord.x1 = 12; window[1].wind_coord.y1 = 41;
  877.             window[1].wind_coord.x2 = 18; window[1].wind_coord.y2 = 80;
  878.             window[2].wind_coord.x1 = 18; window[2].wind_coord.y1 = 1;
  879.             window[2].wind_coord.x2 = 24; window[2].wind_coord.y2 = 40;
  880.             window[3].wind_coord.x1 = 18; window[3].wind_coord.y1 = 41;
  881.             window[3].wind_coord.x2 = 24; window[3].wind_coord.y2 = 80;
  882.             break;
  883.  
  884.            case 1 :
  885.             Windows_Used = 2;
  886.             WIN_SIZE = 5;
  887.             LINE_SIZE = 68;
  888.             window[0].wind_coord.x1 = 12; window[0].wind_coord.y1 = 1;
  889.             window[0].wind_coord.x2 = 18; window[0].wind_coord.y2 = 80;
  890.             window[1].wind_coord.x1 = 18; window[1].wind_coord.y1 = 1;
  891.             window[1].wind_coord.x2 = 24; window[1].wind_coord.y2 = 80;
  892.             break;
  893.     
  894.             case 2 :
  895.             Windows_Used = 2;
  896.             WIN_SIZE = 11;
  897.             LINE_SIZE = 28;
  898.             window[0].wind_coord.x1 = 12; window[0].wind_coord.y1 = 1;
  899.             window[0].wind_coord.x2 = 24; window[0].wind_coord.y2 = 40;
  900.             window[1].wind_coord.x1 = 12; window[1].wind_coord.y1 = 41;
  901.             window[1].wind_coord.x2 = 24; window[1].wind_coord.y2 = 80;
  902.             break;
  903.  
  904.             case 3 :
  905.             Windows_Used = 1;
  906.             WIN_SIZE = 11;
  907.             LINE_SIZE = 68;
  908.             window[0].wind_coord.x1 = 12; window[0].wind_coord.y1 = 1;
  909.             window[0].wind_coord.x2 = 24; window[0].wind_coord.y2 = 80;
  910.             break;
  911.  
  912.             default :
  913.             printf( "invalid use of monitor window types\n" );
  914.             break;
  915.         }
  916.     }
  917. }
  918.  
  919. /*
  920. *    This routine resizes the windows.  It takes space from the output 
  921. *    window to be used by the monitor windows.  It reallocates the space,
  922. *    and then clears the output window (since I don't know what is in
  923. *    it).
  924. */
  925.  
  926. CWK_Resize_Window()
  927. {
  928.     CWK_ERASE_ALL_MON_WIN();
  929.     AVL_DEL_WINDOW( output_win );
  930.     CWK_SETUP_WINDOWS();
  931.     output_win = AVL_MAKE_WINDOW( " GWU ADA MONITOR - Type Ctrl h for help, ESC to leave", 1, 1, ROWS+1, 80, 1, 15 );
  932.  
  933. }
  934.  
  935.